Java Technologies Observer এবং Observable ক্লাস গাইড ও নোট

Observer এবং Observable ক্লাসগুলি Java-এর পুরনো event-driven programming ধারণা এবং observer design pattern অনুসারে কাজ করে। এই দুটি ক্লাস Java 1.0 এ পরিচিত করা হয়েছিল এবং Observer ক্লাস হল একটি ইনটرفেস এবং Observable ক্লাস হল একটি কনক্রিট ক্লাস, যা observer pattern এর সমর্থন করতে ব্যবহৃত হয়।

এই observer pattern একটি one-to-many সম্পর্ক প্রতিষ্ঠা করে, যেখানে এক বা একাধিক observers কে আপডেট করার জন্য একটি observable অবজেক্ট জানানো হয়। যখন observable অবজেক্টের অবস্থান পরিবর্তিত হয়, তখন এটি তার সকল observers-কে জানিয়ে দেয়, যা ইভেন্ট হ্যান্ডলিং এর মাধ্যমে কাজ করে।

1. Observable ক্লাস

Observable ক্লাস একটি কনক্রিট ক্লাস যা একটি অবজেক্টের observable state ধারণ করে এবং তার অবস্থা পরিবর্তিত হলে সেটি তার সংশ্লিষ্ট observers-কে জানিয়ে দেয়। Observable ক্লাসের মাধ্যমে আপনি observer pattern কে সহজেই বাস্তবায়ন করতে পারেন।

Observable ক্লাসের প্রধান মেথডসমূহ:

1. addObserver(Observer o):
   • এটি একটি Observer অবজেক্ট যোগ করার জন্য ব্যবহৃত হয়।
2. deleteObserver(Observer o):
   • এটি একটি নির্দিষ্ট Observer কে সরিয়ে দেয়।
3. deleteObservers():
   • এটি সমস্ত Observer অবজেক্ট সরিয়ে দেয়।
4. setChanged():
   • এটি observable অবজেক্টের অবস্থা পরিবর্তিত হয়েছে বলে চিহ্নিত করে।
5. clearChanged():
   • এটি observable অবজেক্টের পরিবর্তন চিহ্নিত করা মুছে দেয়।
6. hasChanged():
   • এটি চেক করে যে, observable অবজেক্টে কোনও পরিবর্তন ঘটেছে কি না।
7. notifyObservers():
   • এটি সমস্ত observers কে অবহিত করার জন্য ব্যবহৃত হয়।
8. notifyObservers(Object arg):
   • এটি observers-কে একটি নির্দিষ্ট আর্গুমেন্ট সহ অবহিত করে।

Observable ক্লাসের উদাহরণ:

import java.util.Observable;
import java.util.Observer;

class WeatherStation extends Observable {
    private String weatherCondition;

    public void setWeatherCondition(String weatherCondition) {
        this.weatherCondition = weatherCondition;
        setChanged(); // Mark the object as changed
        notifyObservers(weatherCondition); // Notify all observers
    }
}

class WeatherDisplay implements Observer {
    private String weatherCondition;

    @Override
    public void update(Observable o, Object arg) {
        this.weatherCondition = (String) arg;
        System.out.println("Weather updated: " + weatherCondition);
    }
}

public class ObserverPatternExample {
    public static void main(String[] args) {
        // Create observable and observer objects
        WeatherStation weatherStation = new WeatherStation();
        WeatherDisplay weatherDisplay = new WeatherDisplay();

        // Register the observer with the observable
        weatherStation.addObserver(weatherDisplay);

        // Change the weather condition and notify observers
        weatherStation.setWeatherCondition("Sunny");
        weatherStation.setWeatherCondition("Rainy");
    }
}

Output:

Weather updated: Sunny
Weather updated: Rainy

ব্যাখ্যা:

• WeatherStation ক্লাসটি একটি observable অবজেক্ট, এবং যখন এর অবস্থান পরিবর্তিত হয়, তখন এটি WeatherDisplay নামক observer অবজেক্টকে জানিয়ে দেয়।
• setChanged() মেথডের মাধ্যমে অবজেক্টের অবস্থান পরিবর্তিত হওয়ার সিগন্যাল দেয়া হয়।
• notifyObservers() মেথডের মাধ্যমে observer অবজেক্টটি অবহিত করা হয়।

2. Observer ইন্টারফেস

Observer একটি ফাংশনাল ইন্টারফেস যা update() মেথডটিকে ডিফাইন করে। এটি observable অবজেক্টের অবস্থা পরিবর্তিত হলে কল করা হয়। এটি একটি one-to-many সম্পর্ক স্থাপন করতে ব্যবহৃত হয়, যেখানে একাধিক observers একটি observable অবজেক্টের পরিবর্তনগুলো পর্যবেক্ষণ করে।

Observer ইন্টারফেসের মেথড:

• update(Observable o, Object arg):
  • এই মেথডটি observable অবজেক্টের অবস্থা পরিবর্তিত হলে কল করা হয়। এটি observable এবং সংশ্লিষ্ট আর্গুমেন্ট হিসেবে কিছু ডেটা পাস করে।

3. Observer এবং Observable এর মধ্যে পার্থক্য

Observer and Observable Pattern Use Cases

1. Event Handling:
   • এই প্যাটার্নটি ইভেন্ট হ্যান্ডলিংয়ের ক্ষেত্রে ব্যবহার করা যেতে পারে, যেখানে একটি subject অবজেক্ট (যেমন বাটন বা ডেটা মডেল) একাধিক observer অবজেক্টকে অবহিত করে যখন তার অবস্থা পরিবর্তিত হয়।
2. Model-View-Controller (MVC):
   • Observer প্যাটার্নটি MVC আর্কিটেকচারের মধ্যে View (observer) এবং Model (observable) এর মধ্যে যোগাযোগ করার জন্য ব্যবহৃত হয়।
3. Real-time Updates:
   • যখন বিভিন্ন অবজেক্টের মধ্যে real-time data synchronization প্রয়োজন, তখন observer pattern ব্যবহার করা হয়, যেমন weather stations, stock market tracking apps ইত্যাদি।

Java 9 এবং পরবর্তী সংস্করণে Observer Pattern-এর বিকল্প

Java 9 এ Observable এবং Observer ক্লাসগুলি deprecated করা হয়েছে, কারণ এগুলি একটি সিঙ্ক্রোনাস পদ্ধতিতে কাজ করে এবং তাদের সীমাবদ্ধতা রয়েছে। এর পরিবর্তে, Java 9 এবং পরবর্তী সংস্করণে Flow API এবং Reactive Programming সমর্থন করে, যা উন্নত asynchronous এবং non-blocking ডেটা স্ট্রিম পরিচালনা করতে সহায়তা করে।

• Observer pattern একটি পরিচিত ডিজাইন প্যাটার্ন যা একাধিক observer কে একটি observable অবজেক্টের পরিবর্তনের উপর নজর রাখতে সক্ষম করে।
• Observable এবং Observer ক্লাসের মাধ্যমে আপনি একটি one-to-many সম্পর্ক স্থাপন করতে পারেন, যেখানে একটি অবজেক্টের পরিবর্তন অন্য অনেক অবজেক্টকে অবহিত করে।
• Java 9 থেকে Observable এবং Observer ক্লাসগুলো deprecated, এবং এখন Flow API বা Reactive Programming-এর দিকে অগ্রসর হওয়া উচিৎ।

Observer Design Pattern হল একটি Behavioral Design Pattern, যা একটি one-to-many সম্পর্ক প্রতিষ্ঠা করে। এই প্যাটার্নে, একটি অবজারভেবল (subject) অবজারভার (observers) এর তালিকায় পরিবর্তন ঘটালে, সে পরিবর্তনগুলো স্বয়ংক্রিয়ভাবে অবজারভারদের কাছে পাঠানো হয়। এটি একটি ইভেন্ট-চালিত মডেল, যেখানে অবজারভারগণ একটি নির্দিষ্ট অবজারভেবল অবজেক্টের সাথে যুক্ত থাকে এবং অবজারভেবলটি যখন পরিবর্তিত হয়, তখন অবজারভারগুলো আপডেট হয়।

এটি সাধারণত GUI অ্যাপ্লিকেশন, event-driven programming, এবং notification systems-এ ব্যবহৃত হয়। উদাহরণস্বরূপ, যখন একটি ওয়েব পেজের কোনো নির্দিষ্ট তথ্য পরিবর্তিত হয়, তখন সেই তথ্যের সাথে যুক্ত সমস্ত ইউজারকে অবহিত করতে Observer Design Pattern ব্যবহার করা হয়।

Observer Design Pattern এর উপাদান:

1. Subject (Observable):
   • এটি এমন একটি অবজেক্ট যা নিজের অবস্থান বা অবস্থা পরিবর্তিত হলে অবজারভারদের অবগত করে দেয়। এটি এক বা একাধিক অবজারভারকে যুক্ত করতে এবং তাদের অবস্থা পরিবর্তনের খবর পাঠাতে সক্ষম হয়।
2. Observer:
   • এটি একটি ইন্টারফেস বা ক্লাস যা Subject এর পরিবর্তন সম্পর্কে অবহিত হয় এবং তার প্রাসঙ্গিক পরিবর্তনকে গ্রহণ করে।
3. ConcreteSubject:
   • এটি Subject ইন্টারফেসের বাস্তবায়ন, যা অবজারভারদের সাথে সংযুক্ত থাকে এবং তাদেরকে অবহিত করে যখন তার অবস্থা পরিবর্তিত হয়।
4. ConcreteObserver:
   • এটি Observer ইন্টারফেসের বাস্তবায়ন, যা ConcreteSubject থেকে আপডেট পায় এবং সেই অনুযায়ী আচরণ করে।

Observer Design Pattern এর ব্যবহারের উদাহরণ:

Java এর Observer এবং Observable ক্লাসগুলি এই প্যাটার্নের বাস্তবায়ন সরবরাহ করে। তবে, Java 9 থেকে Observable ক্লাসটি deprecated (অবসরপ্রাপ্ত) হয়ে গেছে এবং এখনকার পদ্ধতিতে Observer Design Pattern বাস্তবায়ন করার জন্য java.beans প্যাকেজের PropertyChangeListener এবং অন্যান্য API ব্যবহার করা হয়। তবে, আমরা এখনো Observable এবং Observer ক্লাসের মাধ্যমে এই প্যাটার্নটির একটি সহজ উদাহরণ দেখাব।

Observer Design Pattern এর উদাহরণ:

import java.util.Observable;
import java.util.Observer;

// ConcreteObserver
class TemperatureDisplay implements Observer {
    private String name;

    public TemperatureDisplay(String name) {
        this.name = name;
    }

    @Override
    public void update(Observable o, Object arg) {
        if (o instanceof TemperatureSensor) {
            System.out.println(name + " Display: Temperature updated to " + arg + " degrees.");
        }
    }
}

// ConcreteSubject
class TemperatureSensor extends Observable {
    private int temperature;

    public void setTemperature(int temperature) {
        this.temperature = temperature;
        setChanged();  // Marks the observable as changed
        notifyObservers(temperature);  // Notifies all registered observers with the updated temperature
    }

    public int getTemperature() {
        return temperature;
    }
}

public class ObserverPatternExample {
    public static void main(String[] args) {
        // Creating subject
        TemperatureSensor sensor = new TemperatureSensor();

        // Creating observers
        TemperatureDisplay display1 = new TemperatureDisplay("Main");
        TemperatureDisplay display2 = new TemperatureDisplay("Side");

        // Registering observers
        sensor.addObserver(display1);
        sensor.addObserver(display2);

        // Changing the temperature, which will notify observers
        sensor.setTemperature(25);
        sensor.setTemperature(30);
    }
}

Output:

Main Display: Temperature updated to 25 degrees.
Side Display: Temperature updated to 25 degrees.
Main Display: Temperature updated to 30 degrees.
Side Display: Temperature updated to 30 degrees.

ব্যাখ্যা:

1. TemperatureSensor: এটি ConcreteSubject, যার মধ্যে তাপমাত্রার মান রয়েছে এবং যখন তাপমাত্রা পরিবর্তিত হয়, এটি notifyObservers() মেথডের মাধ্যমে সমস্ত অবজারভারকে অবহিত করে।
2. TemperatureDisplay: এটি ConcreteObserver, যা তাপমাত্রার পরিবর্তনের জন্য update() মেথডটি ইমপ্লিমেন্ট করে। যখন তাপমাত্রা পরিবর্তিত হয়, এটি আপডেট নেয় এবং নতুন তাপমাত্রা দেখায়।
3. addObserver(): এই মেথডের মাধ্যমে অবজারভারকে সাবস্ক্রাইব করা হয়।
4. setChanged(): এটি ইন্ডিকেট করে যে অবজারভেবল (subject) এর অবস্থা পরিবর্তিত হয়েছে এবং অবজারভারদের অবহিত করার জন্য প্রস্তুত।
5. notifyObservers(): এটি সকল অবজারভারকে অবহিত করার জন্য ব্যবহার করা হয়।

Observer Design Pattern এর সুবিধা:

1. Loose Coupling: অবজারভেবল এবং অবজারভারদের মধ্যে শক্তিশালী সংযোগ নেই। Observer ক্লাসগুলি সিস্টেমের বিভিন্ন অংশে পৃথকভাবে কাজ করতে পারে এবং একে অপরের পরিবর্তন সম্পর্কে জানায়।
2. Dynamic Updates: যখনই অবজারভেবল (subject) এর অবস্থা পরিবর্তিত হয়, তখন সমস্ত অবজারভাররা তা অবহিত হয়। এটি ডায়নামিকভাবে তথ্য আপডেট করতে সাহায্য করে।
3. Multiple Observers: একটি অবজারভেবল একাধিক অবজারভারকে আপডেট পাঠাতে সক্ষম, যা একাধিক ডিভাইসে বা অ্যাপ্লিকেশনে ডেটা সিঙ্ক্রোনাইজ করতে সহায়তা করে।

Observer Design Pattern এর সীমাবদ্ধতা:

1. Performance Issues: যদি বেশিরভাগ অবজারভারের সংখ্যা বেশি হয়, তবে notifyObservers() মেথডটি অনেক সময় নষ্ট করতে পারে, কারণ এটি প্রত্যেকটি অবজারভারের update() মেথড কল করে।
2. Complexity: কিছু অ্যাপ্লিকেশনে যখন অনেক অবজারভারের প্রয়োজন হয়, তখন এই প্যাটার্নের কোড কিছুটা জটিল হতে পারে।

Java 9+ - Modern Observer Alternatives:

যেহেতু Observable এবং Observer ক্লাসগুলো Java 9 থেকে deprecated হয়ে গেছে, তাই এই প্যাটার্নটি আধুনিকভাবে বাস্তবায়ন করতে java.beans প্যাকেজের PropertyChangeListener, ReactiveX (RxJava), বা Streams API এর মতো আধুনিক পদ্ধতি ব্যবহার করা যেতে পারে।

Observer Design Pattern হল একটি খুবই কার্যকরী ডিজাইন প্যাটার্ন যা একাধিক অবজারভারের মাধ্যমে অবজারভেবলের পরিবর্তনগুলি ছড়িয়ে দেয়। এটি event-driven programming এ ব্যাপকভাবে ব্যবহৃত হয়। Java-তে এটি Observable এবং Observer ক্লাসের মাধ্যমে ইমপ্লিমেন্ট করা হয়, তবে আধুনিক Java সংস্করণে নতুন পদ্ধতিগুলো ব্যবহার করা হচ্ছে।

Observable ক্লাসটি Java.util প্যাকেজের অংশ এবং এটি Observer design pattern অনুসরণ করে। এটি একটি subject হিসেবে কাজ করে যা বিভিন্ন observers কে তাদের অবস্থা পরিবর্তনের বিষয়ে জানিয়ে দেয়। এই ক্লাসটি বিশেষভাবে উপকারী যখন আপনি অ্যাপ্লিকেশনে একাধিক অবজারভারকে একটি ডেটা পরিবর্তনের বিষয়ে অবহিত করতে চান। যদিও Observable ক্লাসটি Java 9 থেকে deprecated (অবসরপ্রাপ্ত) ঘোষণা করা হয়েছে, তবে এটি এখনও অনেক পুরনো অ্যাপ্লিকেশন এবং কোডবেসে ব্যবহৃত হয়।

Observable ক্লাসের মাধ্যমে subject (অবজেক্ট) তার অবস্থা পরিবর্তন হলে সমস্ত observers-কে জানিয়ে দেয়। এটি ইভেন্ট ড্রিভেন প্রোগ্রামিংয়ে ব্যবহৃত হয়, যেখানে observer অবজেক্টটি subject-এর অবস্থা পরিবর্তন সম্পর্কে জানিয়ে রাখা হয়।

Observable ক্লাসের বৈশিষ্ট্য:

1. Observable Class:
   • Observable একটি abstract class যা setChanged(), notifyObservers(), এবং clearChanged() মতো মেথড সরবরাহ করে।
   • এটি Observer pattern বাস্তবায়ন করে, যার মাধ্যমে অবজেক্টের অবস্থা পরিবর্তিত হলে অন্য অবজেক্টগুলোকে জানানো যায়।
2. Observer Interface:
   • Observer একটি ইন্টারফেস যা update() মেথডটি প্রদান করে। যখন observable অবজেক্টের অবস্থা পরিবর্তিত হয়, তখন observer-এর update() মেথড কল করা হয়।

Observable ক্লাসের প্রধান মেথডসমূহ:

1. setChanged():
   • এটি Observable অবজেক্টের changed ফ্ল্যাগ সেট করে। এটি notifyObservers() এর মাধ্যমে observer-দের অবহিত করার পূর্বে অবশ্যই কল করতে হবে।
2. clearChanged():
   • এটি changed ফ্ল্যাগটি রিসেট করে, অর্থাৎ ডেটা পরিবর্তনের চিহ্ন মুছে ফেলে।
3. notifyObservers():
   • setChanged() কল করার পর, এই মেথডটি সমস্ত observer-দের অবহিত করে যে subject এর অবস্থা পরিবর্তিত হয়েছে।
4. addObserver(Observer o):
   • এটি Observer অবজেক্টটি observable অবজেক্টের তালিকায় যুক্ত করে। অর্থাৎ, যখন subject এর অবস্থা পরিবর্তিত হবে, তখন সেই observer কে অবহিত করা হবে।

ব্যবহার:

এখানে একটি উদাহরণ দেখানো হচ্ছে যেখানে Observable এবং Observer ব্যবহার করে ডেটার পরিবর্তন observer কে জানানো হচ্ছে।

উদাহরণ: Observable এবং Observer ব্যবহার

import java.util.Observable;
import java.util.Observer;

// Observable ক্লাসের একটি কাস্টম উপবর্গ তৈরি করা
class Temperature extends Observable {
    private int temperature;

    public void setTemperature(int temperature) {
        this.temperature = temperature;
        setChanged();  // ডেটা পরিবর্তিত হয়েছে এটি চিহ্নিত করা
        notifyObservers();  // observer-দের অবহিত করা
    }

    public int getTemperature() {
        return temperature;
    }
}

// Observer ক্লাস তৈরি করা
class TemperatureObserver implements Observer {
    private String name;

    public TemperatureObserver(String name) {
        this.name = name;
    }

    @Override
    public void update(Observable observable, Object arg) {
        // observer এ অবস্থা পরিবর্তন হলে কাজ করা
        if (observable instanceof Temperature) {
            Temperature temp = (Temperature) observable;
            System.out.println(name + " received update: Temperature changed to " + temp.getTemperature() + "°C");
        }
    }
}

public class ObservableExample {
    public static void main(String[] args) {
        // Observable এবং Observer তৈরি করা
        Temperature temperature = new Temperature();
        
        TemperatureObserver observer1 = new TemperatureObserver("Observer 1");
        TemperatureObserver observer2 = new TemperatureObserver("Observer 2");

        // observer গুলোকে observable এ যুক্ত করা
        temperature.addObserver(observer1);
        temperature.addObserver(observer2);

        // Temperature সেট করা, যা observer-দের অবহিত করবে
        temperature.setTemperature(30); // Observer 1 এবং Observer 2 এ এই পরিবর্তনটি আসবে
        
        // Temperature পরিবর্তন হলে observer গুলি আবার অবহিত হবে
        temperature.setTemperature(35); // Observer 1 এবং Observer 2 আবার অবহিত হবে
    }
}

Output:

Observer 1 received update: Temperature changed to 30°C
Observer 2 received update: Temperature changed to 30°C
Observer 1 received update: Temperature changed to 35°C
Observer 2 received update: Temperature changed to 35°C

ব্যাখ্যা:

1. Temperature ক্লাসটি Observable ক্লাস থেকে ইনহেরিট করেছে এবং setTemperature() মেথডের মাধ্যমে temperature সেট করছে। যখন temperature পরিবর্তিত হয়, setChanged() এবং notifyObservers() মেথড ব্যবহার করা হচ্ছে যাতে সমস্ত observer অবহিত হয়।
2. TemperatureObserver ক্লাসটি Observer ইন্টারফেস বাস্তবায়ন করে এবং update() মেথডের মাধ্যমে Temperature অবজেক্টের পরিবর্তন সম্পর্কে জানাচ্ছে।
3. ObservableExample ক্লাসে আমরা Observable এবং Observer এর একযোগ ব্যবহারের উদাহরণ দেখেছি।

Observable এবং Observer ক্লাসের ভবিষ্যত:

যেহেতু Observable ক্লাসটি Java 9 থেকে deprecated হয়েছে, এখন এটি পুরনো পদ্ধতির এক অংশ হয়ে দাঁড়িয়েছে। বর্তমানে java.beans প্যাকেজের PropertyChangeListener বা java.util.concurrent প্যাকেজের অন্যান্য ক্লাসগুলো আধুনিক, সুপারিশকৃত বিকল্প হিসেবে ব্যবহৃত হয়। এছাড়াও, Reactive Programming ভিত্তিক ফ্রেমওয়ার্ক, যেমন RxJava এবং Project Reactor, অনেক আধুনিক অ্যাপ্লিকেশন এবং লাইব্রেরিতে ব্যবহার করা হচ্ছে।

Observable এবং Observer ক্লাস Java-তে Observer design pattern বাস্তবায়ন করার জন্য ব্যবহৃত হয়, যেখানে একটি observable অবজেক্ট তার অবস্থা পরিবর্তন হলে observer অবজেক্টগুলোকে অবহিত করে। যদিও Java 9 থেকে এটি deprecated হয়ে গেছে, তবে এর মাধ্যমে একাধিক অবজেক্টের মধ্যে ইভেন্ট ড্রিভেন যোগাযোগ সম্ভব ছিল। বর্তমানে এর পরিবর্তে Reactive Programming বা আধুনিক ইভেন্ট সিস্টেম ব্যবহার করা হচ্ছে।

Observer ইন্টারফেসটি java.util প্যাকেজের একটি পুরনো অংশ, যা observer design pattern-এর জন্য ব্যবহৃত হয়। এটি publish-subscribe মডেলকে বাস্তবায়িত করতে সাহায্য করে, যেখানে একটি অবজেক্ট subject বা observable অন্য একটি অবজেক্ট observer বা subscriber-কে তার অবস্থা পরিবর্তনের বিষয়ে অবহিত (notify) করে।

Observer Design Pattern

Observer Design Pattern হল একটি behavioural design pattern, যা নির্দিষ্ট একটি অবজেক্টের (subject) অবস্থা পরিবর্তিত হলে অন্য এক বা একাধিক অবজেক্ট (observers) কে অবহিত (notify) করে। এটি মূলত loosely coupled কম্পোনেন্টগুলির মধ্যে যোগাযোগ স্থাপন করতে ব্যবহৃত হয়।

Observer Interface:

Observer ইন্টারফেসটি update() মেথড ঘোষণা করে, যা Subject এর অবস্থা পরিবর্তন হলে Observer-কে অবহিত করার জন্য ব্যবহৃত হয়।

Observer Interface-এর মেথড:

• update(Observable o, Object arg): এই মেথডটি Subject (অথবা Observable) এর অবস্থা পরিবর্তিত হলে কল হয়। এখানে o হল সেই অবজেক্ট (subject) যা পরিবর্তিত হয়েছে, এবং arg হচ্ছে সেই পরিবর্তনের সাথে সম্পর্কিত কোনো অতিরিক্ত তথ্য।

Subject (Observable) Interface:

Observable ইন্টারফেসটি একটি অবজেক্টকে তার observers কে অবহিত করতে সক্ষম করে। এটি addObserver(), deleteObserver(), setChanged(), এবং notifyObservers() মেথডগুলির মাধ্যমে observers এর সাথে যোগাযোগ স্থাপন করতে ব্যবহৃত হয়।

Observable Interface-এর মেথড:

• addObserver(Observer o): একটি observer অবজেক্ট তালিকায় যুক্ত করে।
• deleteObserver(Observer o): একটি observer অবজেক্ট তালিকা থেকে সরিয়ে ফেলে।
• setChanged(): অবজেক্টের পরিবর্তন হয়েছে তা নির্দেশ করে।
• notifyObservers(): সমস্ত অবজার্ভারকে অবহিত (notify) করে যে অবজেক্টের অবস্থার পরিবর্তন হয়েছে।

Observer Interface এর মাধ্যমে Notification Management - উদাহরণ:

ধরা যাক, একটি WeatherStation অবজেক্ট (Subject) আছে, যা তার temperature পরিবর্তিত হলে বিভিন্ন Observer (যেমন Display বা Logger) কে অবহিত করবে।

প্রোগ্রাম উদাহরণ:

import java.util.Observable;
import java.util.Observer;

// Subject (Observable) class
class WeatherStation extends Observable {
    private float temperature;

    public void setTemperature(float temperature) {
        this.temperature = temperature;
        setChanged();  // Mark as changed
        notifyObservers();  // Notify all observers
    }

    public float getTemperature() {
        return temperature;
    }
}

// Observer class - Display
class Display implements Observer {
    @Override
    public void update(Observable o, Object arg) {
        if (o instanceof WeatherStation) {
            WeatherStation weatherStation = (WeatherStation) o;
            System.out.println("Display updated with temperature: " + weatherStation.getTemperature() + "°C");
        }
    }
}

// Observer class - Logger
class Logger implements Observer {
    @Override
    public void update(Observable o, Object arg) {
        if (o instanceof WeatherStation) {
            WeatherStation weatherStation = (WeatherStation) o;
            System.out.println("Logger - Temperature recorded: " + weatherStation.getTemperature() + "°C");
        }
    }
}

public class ObserverExample {
    public static void main(String[] args) {
        // Create subject (WeatherStation)
        WeatherStation weatherStation = new WeatherStation();

        // Create observers (Display and Logger)
        Display display = new Display();
        Logger logger = new Logger();

        // Add observers to subject
        weatherStation.addObserver(display);
        weatherStation.addObserver(logger);

        // Change the temperature and notify observers
        weatherStation.setTemperature(25.0f);
        weatherStation.setTemperature(30.5f);
    }
}

Output:

Display updated with temperature: 25.0°C
Logger - Temperature recorded: 25.0°C
Display updated with temperature: 30.5°C
Logger - Temperature recorded: 30.5°C

ব্যাখ্যা:

1. WeatherStation (Subject) তার temperature পরিবর্তন করে, এবং setChanged() এবং notifyObservers() মেথড ব্যবহার করে observers-কে অবহিত (notify) করে।
2. Display এবং Logger ক্লাস দুটি Observer ইন্টারফেস ইমপ্লিমেন্ট করেছে এবং update() মেথডে তাদের প্রতিক্রিয়া দেখাচ্ছে যখন temperature পরিবর্তিত হচ্ছে।
3. প্রথমে 25.0°C এবং পরে 30.5°C তাপমাত্রার পরিবর্তন হলে, Display এবং Logger উভয়ই তাদের সংশ্লিষ্ট বার্তা প্রিন্ট করেছে।

Observer Interface এবং Notification Management - উপকারিতা:

1. Loose Coupling:
   • Observer design pattern এর মাধ্যমে Subject এবং Observer এর মধ্যে কম সংযোগ থাকে। Subject তার অবস্থা পরিবর্তন করলে, Observer কে অবহিত করে, কিন্তু Observer এর কোনো প্রয়োজন নেই Subject কে জানার বা প্রতিক্রিয়া জানার জন্য।
2. Multiple Observers:
   • একাধিক Observer একযোগভাবে একে অপরের অবস্থার পরিবর্তন দেখতে বা প্রক্রিয়াকরণ করতে পারে, যেমন একটি Display এর পাশাপাশি Logger অবজার্ভার থাকতে পারে।
3. Dynamic Updates:
   • যেকোনো সময় Subject তার অবস্থা পরিবর্তন করলে, সমস্ত Observer অবহিত হবে এবং তারা স্বয়ংক্রিয়ভাবে নিজেদের তথ্য আপডেট করবে, যা রিয়েল-টাইম অ্যাপ্লিকেশনগুলির জন্য খুবই কার্যকরী।
4. Flexibility:
   • একটি Subject এ নতুন Observer যোগ করা বা পুরোনো Observer বাদ দেওয়া সহজ। কোনভাবেই একে অপরের ওপর নির্ভরশীল নয়।

Observer Interface এবং Observer Design Pattern Java-তে কার্যকরী notification management এর জন্য ব্যবহৃত হয়। এটি একটি শক্তিশালী ডিজাইন প্যাটার্ন যা বিভিন্ন কম্পোনেন্টগুলির মধ্যে যোগাযোগ স্থাপন করে, যেখানে subject তার অবস্থা পরিবর্তিত হলে এক বা একাধিক observer অবহিত হয়। এই প্যাটার্নটি ডেটা ফ্লো এবং ইভেন্ট ড্রিভেন আর্কিটেকচার (যেমন, GUI অ্যাপ্লিকেশন, সিস্টেম মনিটরিং, ইত্যাদি) তৈরি করতে ব্যবহৃত হয়।

Event-driven Programming (EDP) হল এমন একটি প্রোগ্রামিং প্যারাডাইম যেখানে অ্যাপ্লিকেশনটির প্রবাহ ব্যবহারকারীর events (যেমন, ক্লিক, টাইপিং, স্ক্রলিং ইত্যাদি) বা অন্যান্য trigger এর দ্বারা নিয়ন্ত্রিত হয়। এই ধরনের প্রোগ্রামিংয়ে, বিভিন্ন listeners বা handlers নির্দিষ্ট ইভেন্টগুলিকে হ্যান্ডল করে অ্যাপ্লিকেশনটি পরিচালনা করে।

Java-তে Event-driven programming সাধারণত GUI (Graphical User Interface) অ্যাপ্লিকেশনগুলিতে ব্যবহৃত হয়, যেখানে ব্যবহারকারীর ক্রিয়াগুলির প্রতিক্রিয়া হিসেবে বিভিন্ন ইভেন্ট trigger হয়। Java Swing API, JavaFX ইত্যাদি ইভেন্ট-চালিত প্রোগ্রামিংয়ের জন্য ব্যবহার করা হয়।

এখানে আমরা java.util প্যাকেজের Properties ক্লাস এবং EventListener ব্যবহারের মাধ্যমে একটি সাধারন Event-driven Programming উদাহরণ দেখব।

উদাহরণ: Event-driven Programming in Java

ধরা যাক, আমাদের একটি GUI অ্যাপ্লিকেশন তৈরি করতে হবে যেখানে একটি বোতাম ক্লিক করলে একটি প্রোপার্টি ফাইল থেকে কনফিগারেশন লোড হবে এবং সেই কনফিগারেশনটি GUI এ প্রদর্শিত হবে।

প্রয়োজন:

1. একটি বোতাম ক্লিক করলে Properties ফাইল থেকে কনফিগারেশন লোড হবে।
2. কনফিগারেশনটি GUI এর একটি label-এ প্রদর্শিত হবে।

Steps:

1. Properties ফাইল তৈরি করা।
2. Swing দিয়ে একটি GUI তৈরি করা।
3. Event Handling এর মাধ্যমে Properties ফাইল থেকে কনফিগারেশন লোড করা এবং GUI-তে তা প্রদর্শন করা।

Properties ফাইল: config.properties

username=admin
password=12345
server=localhost

GUI কোড:

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.util.Properties;
import java.io.FileInputStream;
import java.io.IOException;

public class EventDrivenExample extends JFrame implements ActionListener {
    private JButton loadButton;
    private JLabel configLabel;

    public EventDrivenExample() {
        // GUI সৃষ্টির জন্য সেটিংস
        setTitle("Event-driven Programming Example");
        setSize(300, 200);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        // বোতাম এবং লেবেল তৈরি
        loadButton = new JButton("Load Config");
        configLabel = new JLabel("Config will appear here");

        // বোতাম ক্লিক ইভেন্ট হ্যান্ডলার সংযোগ
        loadButton.addActionListener(this);

        // Layout সেটআপ
        setLayout(new FlowLayout());
        add(loadButton);
        add(configLabel);
    }

    // ActionListener এর মাধ্যমে বোতাম ক্লিকের পর কনফিগারেশন লোড হবে
    @Override
    public void actionPerformed(ActionEvent e) {
        // Properties ফাইল থেকে কনফিগারেশন লোড করা
        Properties properties = new Properties();
        try (FileInputStream input = new FileInputStream("config.properties")) {
            properties.load(input);
            
            // কনফিগারেশন লেবেলে প্রদর্শন করা
            String configText = "<html>Username: " + properties.getProperty("username") +
                                 "<br>Password: " + properties.getProperty("password") +
                                 "<br>Server: " + properties.getProperty("server") + "</html>";
            configLabel.setText(configText);
        } catch (IOException ex) {
            configLabel.setText("Error loading config!");
        }
    }

    public static void main(String[] args) {
        // GUI তৈরি এবং প্রদর্শন
        EventDrivenExample frame = new EventDrivenExample();
        frame.setVisible(true);
    }
}

ব্যাখ্যা:

1. JButton ব্যবহারকারীর বোতাম ক্লিকের জন্য তৈরি করা হয়েছে। যখন ব্যবহারকারী বোতামটি ক্লিক করবে, actionPerformed() মেথডটি কল হবে।
2. Properties ক্লাস ব্যবহার করে একটি প্রোপার্টি ফাইল থেকে কনফিগারেশন লোড করা হয়। প্রোপার্টি ফাইলটি config.properties নামে তৈরি করা হয়েছে।
3. যখন কনফিগারেশন লোড হয়ে যাবে, JLabel এর মধ্যে কনফিগারেশন তথ্য প্রদর্শিত হবে।

Output:

1. প্রথমে GUI এর মধ্যে একটি বোতাম এবং একটি লেবেল থাকবে।
2. যখন ব্যবহারকারী "Load Config" বোতামটি ক্লিক করবে, তখন config.properties ফাইল থেকে তথ্য লোড হয়ে JLabel এ প্রদর্শিত হবে।

Event-Driven Programming এর সুবিধা:

1. User Interaction: ব্যবহারকারীর ইন্টারঅ্যাকশন দ্বারা অ্যাপ্লিকেশনটির প্রবাহ নিয়ন্ত্রিত হয়, যা অ্যাপ্লিকেশনটিকে খুবই ডাইনামিক এবং ইউজার-ফ্রেন্ডলি করে তোলে।
2. Real-time Responses: ইভেন্ট-চালিত প্রোগ্রামিং ব্যবহার করে অ্যাপ্লিকেশনগুলো তাত্ক্ষণিক প্রতিক্রিয়া জানাতে সক্ষম হয়, যেমন button click, mouse movement, keyboard input, ইত্যাদি।
3. Modular Design: ইভেন্ট-চালিত প্রোগ্রামিং প্যাটার্ন ব্যবহার করলে অ্যাপ্লিকেশনটির বিভিন্ন অংশ স্বাধীনভাবে কাজ করতে পারে এবং একে অপরের সাথে ইন্টারঅ্যাক্ট করতে পারে।

এখানে আমরা Event-driven programming প্যাটার্নে একটি Swing GUI অ্যাপ্লিকেশন তৈরি করেছি, যেখানে একটি বোতাম ক্লিক করার মাধ্যমে Properties ফাইল থেকে কনফিগারেশন লোড করে তা GUI তে প্রদর্শিত হয়। এই ধরনের প্রোগ্রামিং সাধারণত ব্যবহারকারী ইন্টারঅ্যাকশন ভিত্তিক অ্যাপ্লিকেশন তৈরি করতে ব্যবহৃত হয়। Java Swing, AWT, অথবা JavaFX এর মতো ফ্রেমওয়ার্কগুলোর মাধ্যমে ইভেন্ট-চালিত অ্যাপ্লিকেশন তৈরি করা সম্ভব।